package com.baturu.vin.benz.service.impl.supers;

import com.baturu.vin.base.service.impl.SuperEPCAnalyser;
import com.baturu.vin.benz.consts.BenzConstant;
import com.baturu.vin.benz.consts.BenzLandEnum;
import com.baturu.vin.benz.dto.*;
import com.baturu.vin.benz.service.impl.util.BenzI18nService;
import com.baturu.vin.benz.transformer.BenzGroupTransformerService;
import com.baturu.vin.benz.utils.BenzValidator;
import com.baturu.vin.dto.EPCPartsImageDTO;
import com.baturu.vin.dto.superEPC.*;
import com.baturu.vin.dto.superEPC.entity.SEPCCarTypeQueryParam;
import com.baturu.vin.dto.superEPC.entity.SEPCGroupQueryParam;
import com.baturu.vin.dto.superEPC.entity.SEPCPartsQueryParam;
import com.google.common.collect.Lists;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * BenzSuperEPCAnalyser
 *
 * @author majianming
 * @date 2019-04-03 16:02
 */
@Service
public class BenzSuperEPCAnalyser extends SuperEPCAnalyser {

    @Autowired
    private BenzGroupTransformerService transformerService;

    @Autowired
    private BenzSuperCarTypeService superCarTypeService;

    @Autowired
    private BenzSuperMainGroupService benzSuperMainGroupService;
    @Autowired
    private BenzSuperSubGroupService benzSuperSubGroupService;
    @Autowired
    private BenzI18nService benzI18nService;


    @Autowired
    private BenzSuperPartsService benzSuperPartsService;


    /**
     * 通过车架号查找车型信息（superEPC的格式）
     *
     * @param param
     * @return
     */
    @Override
    public List<SEPCCarTypeDTO> querySuperEPCCarTypeByVinCode(SEPCCarTypeQueryParam param) {

        if (Objects.isNull(param)) {
            return Collections.emptyList();
        }
        benzI18nService.setEPCLand(param.getLangEnum());
        String vinCode = param.getVinCode();
        if (BenzValidator.invalidVinOrFin(vinCode)) {
            return Collections.emptyList();
        }

        String realVinCode = vinCode;
//        如果是fin查询的情况
        if (BenzValidator.validFin(vinCode)) {
            List<BenzVinFinInfoDTO> benzVinFinInfoDTOS = superCarTypeService.queryVinInfoByFin(vinCode);
            benzVinFinInfoDTOS.removeIf(l -> BenzConstant.NO_DEAL_LOCATION.contains(l.getLocation()));
            if (CollectionUtils.isEmpty(benzVinFinInfoDTOS)) {
                return Collections.emptyList();
            }
            if (benzVinFinInfoDTOS.size() > 1) {
                return transformerService.benzVinFinInfoDTOToSuperCarTypeDTO(benzVinFinInfoDTOS).map(Lists::newArrayList).get();
            }
//            如果只查询到一个vin  那么就要直接开始查询车型
            BenzVinFinInfoDTO benzVinFinInfoDTO = benzVinFinInfoDTOS.get(0);
            realVinCode = benzVinFinInfoDTO.getWhc() + benzVinFinInfoDTO.getChassbm() + benzVinFinInfoDTO.getChassIdent();
        }

//        如果到这里了 那么就是都为vin查询车型的情况 记得是使用realVinCode这个字段
        BenzSuperCarInfoDTO superCarInfoDTO = superCarTypeService.queryCarVinInfo(realVinCode);
        if (Objects.isNull(superCarInfoDTO)) {
            return Collections.emptyList();
        }
        return transformerService.benzSuperCarInfoToSuperCarTypeDTO(superCarInfoDTO).map(Lists::newArrayList).get();
    }

    /**
     * 通过vin+组别查询下一组别
     *
     * @param param
     * @return
     */
    @Override
    public List<SEPCGroupDTO> queryGroupByVinCodeAndParentGroup(SEPCGroupQueryParam param) {
        if (Objects.isNull(param)) {
            return Collections.emptyList();
        }
        benzI18nService.setEPCLand(param.getLangEnum());
        //        这里的vin信息必须是17位 不能为后8位的情况
        if (BenzValidator.invalidVin(param.getVinCode())) {
            return Collections.emptyList();
        }
//        重新查询一下车型信息
        BenzSuperCarInfoDTO superCarInfoDTO = superCarTypeService.queryCarVinInfo(param.getVinCode());
        if (Objects.isNull(superCarInfoDTO)) {
            return Collections.emptyList();
        }

//       首先是主组信息 这里认为groupDTO 为空的时候查询主组信息
        SEPCGroupDTO groupDTO = param.getGroupDTO();
        if (Objects.isNull(groupDTO)) {
            List<BenzSuperMainGroupDTO> benzSuperMainGroupDTOS = benzSuperMainGroupService.queryMainGroups(superCarInfoDTO, true);
            return transformerService.benzMainGroupToMainGroup(benzSuperMainGroupDTOS);
        }
        BenzSuperMainGroupDTO mainGroupDTO = transformerService.mainGroupToBenzMainGroup(groupDTO);

        List<BenzSuperSubGroupDTO> benzSuperSubGroupDTOS = benzSuperSubGroupService.querySubGroup(superCarInfoDTO, mainGroupDTO);
        return transformerService.benzSubGroupToGroupDTO(benzSuperSubGroupDTOS, groupDTO);
    }

    /**
     * 通过最后一个组别和vin查询该组别下的配件信息
     *
     * @param param
     * @return
     */
    @Override
    public List<SEPCPartsDTO> queryPartsByVinCodeAndLastGroup(SEPCPartsQueryParam param) {
        if (Objects.isNull(param)) {
            return Collections.emptyList();
        }

        //        这里的vin信息必须是17位 不能为后8位的情况
        if (BenzValidator.invalidVin(param.getVinCode())) {
            return Collections.emptyList();
        }
        benzI18nService.setEPCLand(param.getLangEnum());
//        重新查询一下车型信息
        BenzSuperCarInfoDTO superCarInfoDTO = superCarTypeService.queryCarVinInfo(param.getVinCode());
        if (Objects.isNull(superCarInfoDTO)) {
            return Collections.emptyList();
        }
        Optional<BenzSuperSubGroupDTO> benzSuperSubGroupDTO = transformerService.groupDTOToSubGroupDTO(param.getGroupDTO(), superCarInfoDTO);
        return benzSuperSubGroupDTO.map(l ->
                benzSuperPartsService.queryPartsInfo(l, superCarInfoDTO)
        ).map(transformerService::benzPartsInfoToPartsDTO).get();
    }

    @Override
    public List<SEPCSearchPartsDTO> queryPartsByVinCodeAndParts(SEPCPartsQueryParam param) {
        if (Objects.isNull(param)) {
            return Collections.emptyList();
        }
        //        这里的vin信息必须是17位 不能为后8位的情况
        if (BenzValidator.invalidVin(param.getVinCode())) {
            return Collections.emptyList();
        }
        benzI18nService.setEPCLand(param.getLangEnum());
        //        重新查询一下车型信息
        BenzSuperCarInfoDTO superCarInfoDTO = superCarTypeService.queryCarVinInfo(param.getVinCode());
        if (Objects.isNull(superCarInfoDTO)) {
            return Collections.emptyList();
        }
        SEPCPartsDTO partsDTO = param.getPartsDTO();
        if (Objects.isNull(partsDTO)) {
            return Collections.emptyList();
        }
        String partsCode = partsDTO.getPartsCode();
        if (StringUtils.length(partsCode) == 15) {
            partsCode = partsCode.substring(0, 11);
        }

        List<BenzSuperPartsInfoDTO> benzSuperPartsInfoDTOS = benzSuperPartsService.queryPartsInfoByPartsCode(partsCode, superCarInfoDTO);
        return benzSuperPartsInfoDTOS.stream().map(b -> {
            EPCPartsImageDTO image = new EPCPartsImageDTO();
            image.setImageCode(b.getImageCode());
            SEPCPartsDTO parts = SEPCPartsDTO.builder()
                    .partsCode(StringUtils.trimToEmpty(b.getPartType()) + StringUtils.trimToEmpty(b.getPartNum()) + StringUtils.trimToEmpty(b.getEs2Code()))
                    .installNum(b.getQty())
                    .callout(b.getCallout())
                    .epcName(b.getNounName())
                    .epcDesc(b.getDesc())
                    .btrPartsName(b.getBtrPartsName())
                    .epcPartsImageDTOs(Lists.newArrayList(image))
                    .build();
            return SEPCSearchPartsDTO.builder().partsDTO(parts).build();
        }).collect(Collectors.toList());
    }

    @Override
    public List<SEPCSearchGroupDTO> queryGroupsByVinCodeAndParts(SEPCPartsQueryParam param) {
        if (Objects.isNull(param)) {
            return Collections.emptyList();
        }
        //        这里的vin信息必须是17位 不能为后8位的情况
        if (BenzValidator.invalidVin(param.getVinCode())) {
            return Collections.emptyList();
        }
        BenzLandEnum benzLandEnum = benzI18nService.setEPCLand(param.getLangEnum());
        //        重新查询一下车型信息
        BenzSuperCarInfoDTO superCarInfoDTO = superCarTypeService.queryCarVinInfo(param.getVinCode());
        if (Objects.isNull(superCarInfoDTO)) {
            return Collections.emptyList();
        }
        SEPCPartsDTO partsDTO = param.getPartsDTO();
        if (Objects.isNull(partsDTO)) {
            return Collections.emptyList();
        }
        String partsCode = partsDTO.getPartsCode();
        if (StringUtils.length(partsCode) == 15) {
            partsCode = partsCode.substring(0, 11);
        }

        List<BenzSuperPartsInfoDTO> benzSuperPartsInfoDTOS = benzSuperPartsService.queryPartsInfoByPartsCode(partsCode, superCarInfoDTO);
        List<BenzSuperSubGroupDTO> superSubGroupByParts = benzSuperPartsInfoDTOS.stream().map(l -> BenzSuperSubGroupDTO.builder().mainGroupNo(l.getGroup()).subGroupNo(l.getSubGroup()).catNum(l.getCatNum()).benzImagesDTOS(Lists.newArrayList(BenzImagesDTO.builder().imageCode(l.getImageCode()).build())).build()).collect(Collectors.toList());

        List<BenzSuperSubGroupDTO> benzSuperSubGroupDTOSWithInfo = benzSuperSubGroupService.querySubInfo(superSubGroupByParts, benzLandEnum)
                .stream().filter(l -> {
                    String carNo = l.getCatNum();
                    String mainGroupNo = l.getMainGroupNo();
                    String subGroupNo = l.getSubGroupNo();
                    return benzSuperPartsInfoDTOS.stream().anyMatch(
                            b ->
                                    StringUtils.equals(b.getCatNum(), carNo)
                                            && StringUtils.equals(b.getGroup(), mainGroupNo)
                                            && StringUtils.equals(b.getSubGroup(), subGroupNo)
                    );
                }).collect(Collectors.toList());
        // 查出所有的主组来获得信息
        List<BenzSuperMainGroupDTO> benzSuperMainGroupDTOSFromSubGroup = benzSuperMainGroupService.queryMainGroups(superCarInfoDTO, false)
                .stream().filter(
                        m -> benzSuperSubGroupDTOSWithInfo.stream().anyMatch(
                                s ->
                                        StringUtils.equals(s.getCatNum(), m.getCatNum()) &&
                                                StringUtils.equals(s.getMainGroupNo(), m.getGroupNo()) &&
                                                StringUtils.equals(s.getMainGroupNo(), m.getGroupNo())
                        )
                ).collect(Collectors.toList());

        List<SEPCGroupDTO> mainGroupDTOS = transformerService.benzMainGroupToMainGroup(benzSuperMainGroupDTOSFromSubGroup);
        List<SEPCGroupDTO> groupDTOS = transformerService.benzSubGroupToGroupDTO(benzSuperSubGroupDTOSWithInfo, mainGroupDTOS);


        return groupDTOS.stream().map(l -> SEPCSearchGroupDTO.builder()
                .partsDTO(param.getPartsDTO())
                .groupDTO(l)
                .build()).collect(Collectors.toList());
    }
}
